home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 1 / Atari Mega Archive - Volume 1.iso / language / iconv8_s.arc / ICONT.ARC / UTIL.C < prev   
C/C++ Source or Header  |  1990-03-28  |  6KB  |  325 lines
  1. /*
  2.  *  util.c -- general utility functions.
  3.  */
  4.  
  5. #include <ctype.h>
  6. #include "..\h\config.h"
  7. #include "general.h"
  8. #include "tproto.h"
  9. #include "..\h\cpuconf.h"
  10. #include "globals.h"
  11. #include "trans.h"
  12. #include "tree.h"
  13.  
  14.  
  15. extern int optind;
  16.  
  17. extern char *ofile;
  18.  
  19. /*
  20.  * The following code is operating-system dependent [@util.01].  Define the
  21.  *  characters that terminate a file name prefix.
  22.  */
  23.  
  24. #if PORT
  25. #define Prefix "/"
  26. Deliberate Syntax Error
  27. #endif                    /* PORT */
  28.  
  29. #if AMIGA
  30. #define Prefix "/:"
  31. #endif                    /* AMIGA */
  32.  
  33. #if ATARI_ST
  34. #define Prefix "/:\\"
  35. #endif                    /* ATARI_ST */
  36.  
  37. #if HIGHC_386 || MSDOS || OS2
  38. #define Prefix "/:\\"
  39. #endif                    /* HIGHC_386 || MSDOS || OS2 */
  40.  
  41. #if MACINTOSH
  42. #define Prefix ":"
  43. #endif                    /* MACINTOSH */
  44.  
  45. #if MVS || VM
  46. #define Prefix ""
  47. #endif                    /* MVS || VM */
  48.  
  49. #if UNIX
  50. #define Prefix "/"
  51. #endif                    /* UNIX */
  52.  
  53. #if VMS
  54. #define Prefix "]:"
  55. #endif                    /* VMS */
  56.  
  57. /*
  58.  * End of operating-system specific code.
  59.  */
  60.  
  61. /*
  62.  * Information about Icon functions.
  63.  */
  64.  
  65. /*
  66.  * Number of arguments.
  67.  */
  68.  
  69.  
  70. /*
  71.  * Names of Icon functions.
  72.  */
  73. char *ftable[] = {
  74. #define FncDef(p,n) Lit(p),
  75. #define FncDefV(p) Lit(p),
  76. #include "..\h\fdefs.h"
  77. #undef FncDef
  78. #undef FncDefV
  79.    };
  80.  
  81. int ftbsize = sizeof(ftable)/sizeof(char *);
  82.  
  83. /*
  84.  * alloc - allocate n bytes
  85.  */
  86.  
  87. pointer alloc(n)
  88. unsigned int n;
  89.    {
  90.    pointer a;
  91.  
  92.    if (!(a = malloc((msize)n)))
  93.       quit("out of memory");
  94.    return a;
  95.    }
  96.  
  97. /*
  98.  * salloc - allocate and initialize string 
  99.  */
  100.  
  101. char *salloc(s)
  102. char *s;
  103.    {
  104.  
  105.    return strcpy((char *)alloc((unsigned int)(strlen(s)+1)),s);
  106.    }
  107.  
  108. /*
  109.  * tcalloc - allocate and zero m*n bytes
  110.  */
  111. pointer tcalloc(m,n)
  112. unsigned int m, n;
  113.    {
  114.    pointer a;
  115.  
  116.    if (!(a = calloc(m,n)))
  117.       quit("out of memory");
  118.    return a;
  119.    }
  120.  
  121. /*
  122.  * fparse - break a file name down into component parts.
  123.  *  Result is a pointer to a struct of static pointers good until the next call.
  124.  */
  125. struct fileparts *fparse(s)
  126. char *s;
  127.    {
  128.    static char buf[MaxFileName+2];
  129.    static struct fileparts fp;
  130.    int n;
  131.    char *p, *q;
  132.    char *index();
  133.  
  134. #if MVS         /* for any compiler which takes member names */
  135.    static char extbuf [MaxFileName+2] ;
  136.  
  137.    p = index(s, '(');
  138.    if (p) {
  139.       fp.member = p+1;
  140.       memcpy(extbuf, s, p-s);
  141.       extbuf [p-s]  = '\0';
  142.       s = extbuf;
  143.    }
  144.    else fp.member = s + strlen(s);
  145. #endif                    /* MVS */
  146.  
  147.    q = s;
  148.    fp.ext = p = s + strlen(s);
  149.    while (--p >= s) {
  150.       if (*p == '.' && *fp.ext == '\0')
  151.          fp.ext = p;
  152.       else if (index(Prefix,*p)) {
  153.          q = p+1;
  154.          break;
  155.          }
  156.       }
  157.    fp.dir = buf;
  158.    n = q - s;
  159.    strncpy(fp.dir,s,n);
  160.    fp.dir[n] = '\0';
  161.    fp.name = buf + n + 1;
  162.    n = fp.ext - q;
  163.    strncpy(fp.name,q,n);
  164.    fp.name[n] = '\0';
  165.    return &fp;
  166.    }
  167.  
  168. /*
  169.  * makename - make a file name, optionally substituting a new dir and/or ext
  170.  */
  171. char *makename(dest,d,name,e)
  172. char *dest, *d, *name, *e;
  173.    {
  174.    struct fileparts fp;
  175.    fp = *fparse(name);
  176.    if (d != NULL)
  177.       fp.dir = d;
  178.    if (e != NULL)
  179.       fp.ext = e;
  180.  
  181. #if MVS
  182.    if (*fp.member)
  183.       sprintf(dest,"%s%s%s(%s", fp.dir, fp.name, fp.ext, fp.member);
  184.    else
  185. #endif                    /* MVS */
  186.  
  187.    sprintf(dest,"%s%s%s",fp.dir,fp.name,fp.ext);
  188.    return dest;
  189.    }
  190.  
  191. /*
  192.  * quit - immediate exit with error message
  193.  */
  194.  
  195. novalue quit(msg)
  196. char *msg;
  197.    {
  198.    quitf(msg,"");
  199.    }
  200.  
  201. /*
  202.  * quitf - immediate exit with message format and argument
  203.  */
  204. novalue quitf(msg,arg)
  205. char *msg, *arg;
  206.    {
  207.  
  208.  
  209.    extern char *progname;
  210.    fprintf(stderr,"%s: ",progname);
  211.    fprintf(stderr,msg,arg);
  212.    fprintf(stderr,"\n");
  213.  
  214. #ifndef VarTran
  215.    if (ofile)
  216.       unlink(ofile);            /* remove bad icode file */
  217. #endif                    /* VarTran */
  218.  
  219.    exit(ErrorExit);
  220.    }
  221.  
  222. /*
  223.  * tsyserr is called for fatal errors.  The message s is produced and the
  224.  *  translator exits.
  225.  */
  226. novalue tsyserr(s)
  227. char *s;
  228.    {
  229.  
  230.  
  231.    if (tok_loc.n_file)
  232.       fprintf(stderr, "File %s; ", tok_loc.n_file);
  233.    fprintf(stderr, "Line %d # %s\n", in_line, s);
  234.  
  235.    exit(ErrorExit);
  236.    }
  237.  
  238.  
  239. /*
  240.  * round2 - round an integer up to the next power of 2.
  241.  */
  242. unsigned int round2(n)
  243. unsigned int n;
  244.    {
  245.    unsigned int b = 1;
  246.    while (b < n)
  247.       b <<= 1;
  248.    return b;
  249.    }
  250.  
  251.  
  252. /*
  253.  * sizearg - process -S command option.
  254.  */
  255.  
  256. struct keyptr {            /* structure for listing option chars */
  257.    char *cmd;                /* option character(s) */
  258.    unsigned int *valp;            /* pointer to value word */
  259.    };
  260.  
  261. static struct keyptr keytable[] = {    /* maps keys to store addresses */
  262.  
  263. #define Size(cmd,vname,defalt) cmd, &vname,
  264. #define MinSize(x,y,z)
  265. #include "sizes.h"            \* initialize from "sizes.h" data *\
  266. #undef Size
  267. #undef MinSize
  268.    0, 0,                /* terminate with null entry */
  269.    };
  270.  
  271. novalue sizearg(arg,argv)
  272. char *arg;
  273. char **argv;
  274.    {
  275.    struct keyptr *k;            /* key table pointer */
  276.    char *s;                /* value string pointer */
  277.    int v;                /* option value */
  278.  
  279.    for (k = keytable; k->cmd; k++)    /* search for key match */
  280.       if (arg[0] == k->cmd[0] && (arg[0] != 'h' || arg[1] == k->cmd[1]))
  281.          break;
  282.  
  283.    if (k->cmd == NULL)            /* abort if not found */
  284.       quitf("unrecognized -S option: -S%s",arg);
  285.  
  286.    if (arg[0] == 'h')
  287.       s = &arg[2];            /* find value */
  288.    else
  289.       s = &arg[1];
  290.       
  291.    if (*s == '\0') {            /* if value is in next arg */
  292.       s = argv[optind++];
  293.       if (s == NULL)
  294.          quitf("missing value: -S%s", arg);
  295.       }
  296.  
  297.    v = (int)atol(s);                /* convert integer -- check */
  298.    if (v <= 0)
  299.       quitf("illegal value: -S%s", arg);
  300.    *k->valp = v;            /* store result */
  301.    }
  302.  
  303.  
  304. /*
  305.  * smatch - case-insensitive string match - returns nonzero if they match
  306.  */
  307. int smatch(s,t)
  308. char *s, *t;
  309.    {
  310.    char a, b;
  311.    for (;;) {
  312.       while (*s == *t)
  313.          if (*s++ == '\0')
  314.             return 1;
  315.          else
  316.             t++;
  317.       a = *s++;
  318.       b = *t++;
  319.       if (isupper(a))  a = tolower(a);
  320.       if (isupper(b))  b = tolower(b);
  321.       if (a != b)
  322.          return 0;
  323.       }
  324.    }
  325.